home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / php / pear / HTML / Template / ITX.php < prev    next >
PHP Script  |  2004-03-24  |  27KB  |  833 lines
  1. <?php
  2. //
  3. // +----------------------------------------------------------------------+
  4. // | PHP version 4.0                                                      |
  5. // +----------------------------------------------------------------------+
  6. // | Copyright (c) 1997-2001 The PHP Group                                |
  7. // +----------------------------------------------------------------------+
  8. // | This source file is subject to version 2.02 of the PHP license,      |
  9. // | that is bundled with this package in the file LICENSE, and is        |
  10. // | available at through the world-wide-web at                           |
  11. // | http://www.php.net/license/2_02.txt.                                 |
  12. // | If you did not receive a copy of the PHP license and are unable to   |
  13. // | obtain it through the world-wide-web, please send a note to          |
  14. // | license@php.net so we can mail you a copy immediately.               |
  15. // +----------------------------------------------------------------------+
  16. // | Author: Ulf Wendel <ulf.wendel@phpdoc.de>                            |
  17. // +----------------------------------------------------------------------+
  18. //
  19. // $Id: ITX.php,v 1.8 2003/03/12 02:25:16 pajoye Exp $
  20. //
  21.  
  22. require_once('HTML/Template/IT.php');
  23. require_once 'HTML/Template/IT_Error.php';
  24.  
  25. /**
  26. * Integrated Template Extension - ITX
  27. *
  28. * With this class you get the full power of the phplib template class.
  29. * You may have one file with blocks in it but you have as well one main file
  30. * and multiple files one for each block. This is quite usefull when you have
  31. * user configurable websites. Using blocks not in the main template allows
  32. * you to modify some parts of your layout easily.
  33. *
  34. * Note that you can replace an existing block and add new blocks at runtime.
  35. * Adding new blocks means changing a variable placeholder to a block.
  36. *
  37. * @author   Ulf Wendel <uw@netuse.de>
  38. * @access   public
  39. * @version  $Id: ITX.php,v 1.8 2003/03/12 02:25:16 pajoye Exp $
  40. * @package  IT[X]
  41. */
  42. class HTML_Template_ITX extends HTML_Template_IT {
  43.  
  44.     /**
  45.     * Array with all warnings.
  46.     * @var       array
  47.     * @access    public
  48.     * @see       $printWarning, $haltOnWarning, warning()
  49.     */
  50.     var $warn = array();
  51.  
  52.     /**
  53.     * Print warnings?
  54.     * @var       array
  55.     * @access    public
  56.     * @see      $haltOnWarning, $warn, warning()
  57.     */
  58.     var $printWarning = false;
  59.  
  60.     /**
  61.     * Call die() on warning?
  62.     * @var         boolean
  63.     * @access    public
  64.     * @see       $warn, $printWarning, warning()
  65.     */
  66.     var $haltOnWarning = false;
  67.  
  68.     /**
  69.     * RegExp used to test for a valid blockname.
  70.     * @var    string
  71.     */
  72.     var $checkblocknameRegExp = '';
  73.  
  74.     /**
  75.     * Functionnameprefix used when searching function calls in the template.
  76.     * @var    string
  77.     */
  78.     var $functionPrefix = 'func_';
  79.  
  80.     /**
  81.     * Functionname RegExp.
  82.     * @var    string
  83.     */
  84.     var $functionnameRegExp = '[_a-zA-Z]+[A-Za-z_0-9]*';
  85.  
  86.     /**
  87.     * RegExp used to grep function calls in the template.
  88.     *
  89.     * The variable gets set by the constructor.
  90.     *
  91.     * @var    string
  92.     * @see    HTML_Template_IT()
  93.     */
  94.     var $functionRegExp = '';
  95.  
  96.     /**
  97.     * List of functions found in the template.
  98.     *
  99.     * @var    array
  100.     */
  101.     var $functions         = array();
  102.  
  103.     /**
  104.     * List of callback functions specified by the user.
  105.     *
  106.     * @var    array
  107.     */
  108.     var $callback         = array();
  109.  
  110.     /**
  111.     * Builds some complex regexps and calls the constructor
  112.     * of the parent class.
  113.     *
  114.     * Make sure that you call this constructor if you derive your own
  115.     * template class from this one.
  116.     *
  117.     * @see    HTML_Template_IT()
  118.     */
  119.     function HTML_Template_ITX($root = '')
  120.     {
  121.  
  122.         $this->checkblocknameRegExp = '@' . $this->blocknameRegExp . '@';
  123.         $this->functionRegExp = '@' . $this->functionPrefix . '(' .
  124.                                 $this->functionnameRegExp . ')\s*\(@sm';
  125.  
  126.         $this->HTML_Template_IT($root);
  127.     } // end func constructor
  128.  
  129.     function init()
  130.     {
  131.         $this->free();
  132.         $this->buildFunctionlist();
  133.         $this->findBlocks($this->template);
  134.         // we don't need it any more
  135.         $this->template = '';
  136.         $this->buildBlockvariablelist();
  137.  
  138.     } // end func init
  139.  
  140.     /**
  141.     * Replaces an existing block with new content.
  142.     *
  143.     * This function will replace a block of the template and all blocks
  144.     * contained in the replaced block and add a new block insted, means
  145.     * you can dynamically change your template.
  146.     *
  147.     * Note that changing the template structure violates one of the IT[X]
  148.     * development goals. I've tried to write a simple to use template engine
  149.     * supporting blocks. In contrast to other systems IT[X] analyses the way
  150.     * you've nested blocks and knows which block belongs into another block.
  151.     * The nesting information helps to make the API short and simple. Replacing
  152.     * blocks does not only mean that IT[X] has to update the nesting
  153.     * information (relatively time consumpting task) but you have to make sure
  154.     * that you do not get confused due to the template change itself.
  155.     *
  156.     * @param    string      Blockname
  157.     * @param    string      Blockcontent
  158.     * @param    boolean     true if the new block inherits the content
  159.     *                       of the old block
  160.     * @return   boolean
  161.     * @throws   IT_Error
  162.     * @see      replaceBlockfile(), addBlock(), addBlockfile()
  163.     * @access   public
  164.     */
  165.     function replaceBlock($block, $template, $keep_content = false)
  166.     {
  167.         if (!isset($this->blocklist[$block])) {
  168.             return new IT_Error(
  169.             "The block "."'$block'".
  170.             " does not exist in the template and thus it can't be replaced.",
  171.             __FILE__, __LINE__
  172.             );
  173.         }
  174.         if ('' == $template) {
  175.             return new IT_Error('No block content given.', __FILE__, __LINE__);
  176.         }
  177.         if ($keep_content) {
  178.             $blockdata = $this->blockdata[$block];
  179.         }
  180.  
  181.         // remove all kinds of links to the block / data of the block
  182.         $this->removeBlockData($block);
  183.  
  184.         $template = "<!-- BEGIN $block -->" . $template . "<!-- END $block -->";
  185.         $parents = $this->blockparents[$block];
  186.         $this->findBlocks($template);
  187.         $this->blockparents[$block] = $parents;
  188.  
  189.         // KLUDGE: rebuild the list for all block - could be done faster
  190.         $this->buildBlockvariablelist();
  191.  
  192.         if ($keep_content) {
  193.             $this->blockdata[$block] = $blockdata;
  194.         }
  195.  
  196.         // old TODO - I'm not sure if we need this
  197.         // update caches
  198.  
  199.         return true;
  200.     } // end func replaceBlock
  201.  
  202.     /**
  203.     * Replaces an existing block with new content from a file.
  204.     *
  205.     * @brother replaceBlock()
  206.     * @param    string    Blockname
  207.     * @param    string    Name of the file that contains the blockcontent
  208.     * @param    boolean   true if the new block inherits the content of the old block
  209.     */
  210.     function replaceBlockfile($block, $filename, $keep_content = false)
  211.     {
  212.         return $this->replaceBlock($block, $this->getFile($filename), $keep_content);
  213.     } // end func replaceBlockfile
  214.  
  215.     /**
  216.     * Adds a block to the template changing a variable placeholder
  217.     * to a block placeholder.
  218.     *
  219.     * Add means "replace a variable placeholder by a new block".
  220.     * This is different to PHPLibs templates. The function loads a
  221.     * block, creates a handle for it and assigns it to a certain
  222.     * variable placeholder. To to the same with PHPLibs templates you would
  223.     * call set_file() to create the handle and parse() to assign the
  224.     * parsed block to a variable. By this PHPLibs templates assume
  225.     * that you tend to assign a block to more than one one placeholder.
  226.     * To assign a parsed block to more than only the placeholder you specify
  227.     * in this function you have to use a combination of getBlock()
  228.     * and setVariable().
  229.     *
  230.     * As no updates to cached data is necessary addBlock() and addBlockfile()
  231.     * are rather "cheap" meaning quick operations.
  232.     *
  233.     * The block content must not start with <!-- BEGIN blockname -->
  234.     * and end with <!-- END blockname --> this would cause overhead and
  235.     * produce an error.
  236.     *
  237.     * @param    string    Name of the variable placeholder, the name must be unique
  238.     *                     within the template.
  239.     * @param    string    Name of the block to be added
  240.     * @param    string    Content of the block
  241.     * @return   boolean
  242.     * @throws   IT_Error
  243.     * @see      addBlockfile()
  244.     * @access   public
  245.     */
  246.     function addBlock($placeholder, $blockname, $template)
  247.     {
  248.  
  249.         // Don't trust any user even if it's a programmer or yourself...
  250.         if ('' == $placeholder) {
  251.  
  252.             return new IT_Error('No variable placeholder given.',
  253.                                 __FILE__, __LINE__
  254.                                 );
  255.  
  256.         } else if ( '' == $blockname ||
  257.                     !preg_match($this->checkblocknameRegExp, $blockname)
  258.         ) {
  259.  
  260.             return new IT_Error("No or invalid blockname '$blockname' given.",
  261.                     __FILE__, __LINE__
  262.                     );
  263.  
  264.         } else if ('' == $template) {
  265.  
  266.             return new IT_Error('No block content given.', __FILE__, __LINE__);
  267.  
  268.         } else if (isset($this->blocklist[$blockname])) {
  269.  
  270.             return new IT_Error('The block already exists.',
  271.                                 __FILE__, __LINE__
  272.                             );
  273.  
  274.         }
  275.  
  276.         // find out where to insert the new block
  277.         $parents = $this->findPlaceholderBlocks($placeholder);
  278.         if (0 == count($parents)) {
  279.  
  280.             return new IT_Error(
  281.                 "The variable placeholder".
  282.                 " '$placeholder' was not found in the template.",
  283.                 __FILE__, __LINE__
  284.             );
  285.  
  286.         } else if ( count($parents) > 1 ) {
  287.  
  288.             reset($parents);
  289.             while (list($k, $parent) = each($parents)) {
  290.                 $msg .= "$parent, ";
  291.             }
  292.             $msg = substr($parent, -2);
  293.  
  294.             return new IT_Error("The variable placeholder "."'$placeholder'".
  295.                                 " must be unique, found in multiple blocks '$msg'.",
  296.                                 __FILE__, __LINE__
  297.                                 );
  298.         }
  299.  
  300.         $template = "<!-- BEGIN $blockname -->" . $template . "<!-- END $blockname -->";
  301.         $this->findBlocks($template);
  302.         if ($this->flagBlocktrouble) {
  303.             return false;    // findBlocks() already throws an exception
  304.         }
  305.         $this->blockinner[$parents[0]][] = $blockname;
  306.         $this->blocklist[$parents[0]] = preg_replace(
  307.                     '@' . $this->openingDelimiter . $placeholder .
  308.                     $this->closingDelimiter . '@',
  309.  
  310.                     $this->openingDelimiter . '__' . $blockname . '__' .
  311.                     $this->closingDelimiter,
  312.  
  313.                     $this->blocklist[$parents[0]]
  314.                 );
  315.  
  316.         $this->deleteFromBlockvariablelist($parents[0], $placeholder);
  317.         $this->updateBlockvariablelist($blockname);
  318.     /*
  319.     // check if any inner blocks were found
  320.     if(is_array($this->blockinner[$blockname]) and count($this->blockinner[$blockname]) > 0) {
  321.         // loop through inner blocks, registering the variable placeholders in each
  322.         foreach($this->blockinner[$blockname] as $childBlock) {
  323.             $this->updateBlockvariablelist($childBlock);
  324.         }
  325.     }
  326.     */
  327.         return true;
  328.     } // end func addBlock
  329.  
  330.     /**
  331.     * Adds a block taken from a file to the template changing a variable
  332.     * placeholder to a block placeholder.
  333.     *
  334.     * @param      string    Name of the variable placeholder to be converted
  335.     * @param      string    Name of the block to be added
  336.     * @param      string    File that contains the block
  337.     * @brother    addBlock()
  338.     */
  339.     function addBlockfile($placeholder, $blockname, $filename)
  340.     {
  341.         return $this->addBlock($placeholder, $blockname, $this->getFile($filename));
  342.     } // end func addBlockfile
  343.  
  344.     /**
  345.     * Returns the name of the (first) block that contains
  346.     * the specified placeholder.
  347.     *
  348.     * @param    string  Name of the placeholder you're searching
  349.     * @param    string  Name of the block to scan. If left out (default)
  350.     *                   all blocks are scanned.
  351.     * @return   string  Name of the (first) block that contains
  352.     *                   the specified placeholder.
  353.     *                   If the placeholder was not found or an error occured
  354.     *                   an empty string is returned.
  355.     * @throws   IT_Error
  356.     * @access   public
  357.     */
  358.     function placeholderExists($placeholder, $block = '')
  359.     {
  360.         if ('' == $placeholder) {
  361.             new IT_Error('No placeholder name given.', __FILE__, __LINE__);
  362.             return '';
  363.         }
  364.  
  365.         if ('' != $block && !isset($this->blocklist[$block])) {
  366.             new IT_Error("Unknown block '$block'.", __FILE__, __LINE__);
  367.             return '';
  368.         }
  369.  
  370.         // name of the block where the given placeholder was found
  371.         $found = '';
  372.  
  373.         if ('' != $block) {
  374.  
  375.             if (is_array($variables = $this->blockvariables[$block])) {
  376.  
  377.                 // search the value in the list of blockvariables
  378.                 reset($variables);
  379.                 while (list($k, $variable) = each($variables)) {
  380.                     if ($k == $placeholder) {
  381.                         $found = $block;
  382.                         break;
  383.                     }
  384.                 }
  385.             }
  386.  
  387.         } else {
  388.  
  389.             // search all blocks and return the name of the first block that
  390.             // contains the placeholder
  391.             reset($this->blockvariables);
  392.             while (list($blockname, $variables) = each($this->blockvariables)){
  393.  
  394.                 if (is_array($variables) && isset($variables[$placeholder])) {
  395.                     $found = $blockname;
  396.                     break;
  397.                 }
  398.             }
  399.  
  400.         }
  401.  
  402.         return $found;
  403.     } // end func placeholderExists
  404.  
  405.     /**
  406.     * Checks the list of function calls in the template and
  407.     * calls their callback function.
  408.     *
  409.     * @access    public
  410.     */
  411.     function performCallback()
  412.     {
  413.  
  414.         reset($this->functions);
  415.         while (list($func_id, $function) = each($this->functions)) {
  416.  
  417.             if (isset($this->callback[$function['name']])) {
  418.  
  419.                 if ('' != $this->callback[$function['name']]['object']) {
  420.                     $this->variableCache['__function' . $func_id . '__'] =
  421.                         call_user_func(
  422.                         array(
  423.                         &$GLOBALS[$this->callback[$function['name']]['object']],
  424.                         $this->callback[$function['name']]['function']),
  425.                         $function['args']
  426.                        );
  427.                 } else {
  428.                     $this->variableCache['__function' . $func_id . '__'] =
  429.                             call_user_func(
  430.                             $this->callback[$function['name']]['function'],
  431.                             $function['args']
  432.                         );
  433.                 }
  434.  
  435.             }
  436.  
  437.         }
  438.  
  439.     } // end func performCallback
  440.  
  441.     /**
  442.     * Returns a list of all function calls in the current template.
  443.     *
  444.     * @return   array
  445.     * @access   public
  446.     */
  447.     function getFunctioncalls()
  448.     {
  449.         return $this->functions;
  450.     } // end func getFunctioncalls
  451.  
  452.     /**
  453.     * Replaces a function call with the given replacement.
  454.     *
  455.     * @param    int       Function ID
  456.     * @param    string    Replacement
  457.     * @deprec
  458.     */
  459.     function setFunctioncontent($functionID, $replacement)
  460.     {
  461.         $this->variableCache['__function' . $functionID . '__'] = $replacement;
  462.     } // end func setFunctioncontent
  463.  
  464.     /**
  465.     * Sets a callback function.
  466.     *
  467.     * IT[X] templates (note the X) can contain simple function calls.
  468.     * "function call" means that the editor of the template can add
  469.     * special placeholder to the template like 'func_h1("embedded in h1")'.
  470.     * IT[X] will grab this function calls and allow you to define a callback
  471.     * function for them.
  472.     *
  473.     * This is an absolutely evil feature. If your application makes heavy
  474.     * use of such callbacks and you're even implementing if-then etc. on
  475.     * the level of a template engine you're reiventing the wheel... - that's
  476.     * actually how PHP came into life. Anyway, sometimes it's handy.
  477.     *
  478.     * Consider also using XML/XSLT or native PHP. And please do not push
  479.     * IT[X] any further into this direction of adding logics to the template
  480.     * engine.
  481.     *
  482.     * For those of you ready for the X in IT[X]:
  483.     *
  484.     * <?php
  485.     * ...
  486.     * function h_one($args) {
  487.     *    return sprintf('<h1>%s</h1>', $args[0]);
  488.     * }
  489.     *
  490.     * ...
  491.     * $itx = new HTML_Template_ITX( ... );
  492.     * ...
  493.     * $itx->setCallbackFunction('h1', 'h_one');
  494.     * $itx->performCallback();
  495.     * ?>
  496.     *
  497.     * template:
  498.     * func_h1('H1 Headline');
  499.     *
  500.     * @param    string    Function name in the template
  501.     * @param    string    Name of the callback function
  502.     * @param    string    Name of the callback object
  503.     * @return   boolean   False on failure.
  504.     * @throws   IT_Error
  505.     * @access   public
  506.     */
  507.     function
  508.     setCallbackFunction($tplfunction, $callbackfunction, $callbackobject = '')
  509.     {
  510.  
  511.         if ('' == $tplfunction || '' == $callbackfunction) {
  512.             return new IT_Error(
  513.                 "No template function "."('$tplfunction')".
  514.                 " and/or no callback function ('$callback') given.",
  515.                     __FILE__, __LINE__
  516.                 );
  517.         }
  518.         $this->callback[$tplfunction] = array(
  519.                                           "function"    => $callbackfunction,
  520.                                           "object"        => $callbackobject
  521.                                         );
  522.  
  523.         return true;
  524.     } // end func setCallbackFunction
  525.  
  526.     /**
  527.     * Sets the Callback function lookup table
  528.     *
  529.     * @param    array    function table
  530.     *                    array[templatefunction] =
  531.     *                       array(
  532.     *                               "function" => userfunction,
  533.     *                               "object" => userobject
  534.     *                       )
  535.     * @access    public
  536.     */
  537.     function setCallbackFuntiontable($functions)
  538.     {
  539.         $this->callback = $functions;
  540.     } // end func setCallbackFunctiontable
  541.  
  542.     /**
  543.     * Recursively removes all data assiciated with a block, including all inner blocks
  544.     *
  545.     * @param    string  block to be removed
  546.     */
  547.     function removeBlockData($block)
  548.     {
  549.         if (isset($this->blockinner[$block])) {
  550.             foreach ($this->blockinner[$block] as $k => $inner) {
  551.                 $this->removeBlockData($inner);
  552.             }
  553.  
  554.             unset($this->blockinner[$block]);
  555.         }
  556.  
  557.         unset($this->blocklist[$block]);
  558.         unset($this->blockdata[$block]);
  559.         unset($this->blockvariables[$block]);
  560.         unset($this->touchedBlocks[$block]);
  561.  
  562.     } // end func removeBlockinner
  563.  
  564.     /**
  565.     * Returns a list of blocknames in the template.
  566.     *
  567.     * @return    array    [blockname => blockname]
  568.     * @access    public
  569.     * @see        blockExists()
  570.     */
  571.     function getBlocklist()
  572.     {
  573.         $blocklist = array();
  574.         foreach ($this->blocklist as $block => $content) {
  575.             $blocklist[$block] = $block;
  576.         }
  577.  
  578.         return $blocklist;
  579.     } // end func getBlocklist
  580.  
  581.     /**
  582.     * Checks wheter a block exists.
  583.     *
  584.     * @param    string
  585.     * @return    boolean
  586.     * @access    public
  587.     * @see        getBlocklist()
  588.     */
  589.     function blockExists($blockname)
  590.     {
  591.         return isset($this->blocklist[$blockname]);
  592.     } // end func blockExists
  593.  
  594.     /**
  595.     * Returns a list of variables of a block.
  596.     *
  597.     * @param    string    Blockname
  598.     * @return    array    [varname => varname]
  599.     * @access    public
  600.     * @see        BlockvariableExists()
  601.     */
  602.     function getBlockvariables($block)
  603.     {
  604.         if (!isset($this->blockvariables[$block])) {
  605.             return array();
  606.         }
  607.  
  608.         $variables = array();
  609.         foreach ($this->blockvariables[$block] as $variable => $v) {
  610.             $variables[$variable] = $variable;
  611.         }
  612.  
  613.         return $variables;
  614.     } // end func getBlockvariables
  615.  
  616.     /**
  617.     * Checks wheter a block variable exists.
  618.     *
  619.     * @param    string    Blockname
  620.     * @param    string    Variablename
  621.     * @return    boolean
  622.     * @access    public
  623.     * @see    getBlockvariables()
  624.     */
  625.     function BlockvariableExists($block, $variable)
  626.     {
  627.         return isset($this->blockvariables[$block][$variable]);
  628.     } // end func BlockvariableExists
  629.  
  630.     /**
  631.     * Builds a functionlist from the template.
  632.     */
  633.     function buildFunctionlist()
  634.     {
  635.         $this->functions = array();
  636.  
  637.         $template = $this->template;
  638.         $num = 0;
  639.  
  640.         while (preg_match($this->functionRegExp, $template, $regs)) {
  641.  
  642.             $pos = strpos($template, $regs[0]);
  643.             $template = substr($template, $pos + strlen($regs[0]));
  644.  
  645.             $head = $this->getValue($template, ')');
  646.             $args = array();
  647.  
  648.             $this->template = str_replace($regs[0] . $head . ')',
  649.                                 '{__function' . $num . '__}', $this->template
  650.                             );
  651.             $template = str_replace($regs[0] . $head . ')',
  652.                         '{__function' . $num . '__}', $template
  653.                         );
  654.  
  655.             while ('' != $head && $args2 = $this->getValue($head, ',')) {
  656.                 $arg2 = trim($args2);
  657.                 $args[] = ('"' == $arg2{0} || "'" == $arg2{0}) ?
  658.                                     substr($arg2, 1, -1) : $arg2;
  659.                 if ($arg2 == $head) {
  660.                     break;
  661.                 }
  662.                 $head = substr($head, strlen($arg2) + 1);
  663.             }
  664.  
  665.             $this->functions[$num++] = array(
  666.                                                 'name'    => $regs[1],
  667.                                                 'args'    => $args
  668.                                             );
  669.         }
  670.  
  671.     } // end func buildFunctionlist
  672.  
  673.  
  674.     function getValue($code, $delimiter) {
  675.         if ('' == $code) {
  676.             return '';
  677.         }
  678.  
  679.         if (!is_array($delimiter)) {
  680.             $delimiter = array( $delimiter => true );
  681.         }
  682.  
  683.         $len         = strlen($code);
  684.         $enclosed    = false;
  685.         $enclosed_by = '';
  686.  
  687.         if (isset($delimiter[$code[0]])) {
  688.  
  689.             $i = 1;
  690.  
  691.         } else {
  692.  
  693.             for ($i = 0; $i < $len; ++$i) {
  694.  
  695.                 $char = $code[$i];
  696.  
  697.                 if (
  698.                         ('"' == $char || "'" == $char) &&
  699.                         ($char == $enclosed_by || '' == $enclosed_by) &&
  700.                         (0 == $i || ($i > 0 && '\\' != $code[$i - 1]))
  701.                     ){
  702.  
  703.                     if (!$enclosed) {
  704.                         $enclosed_by = $char;
  705.                     } else {
  706.                         $enclosed_by = "";
  707.                     }
  708.                     $enclosed = !$enclosed;
  709.  
  710.                 }
  711.                 if (!$enclosed && isset($delimiter[$char])) {
  712.                     break;
  713.                 }
  714.             }
  715.  
  716.         }
  717.  
  718.         return substr($code, 0, $i);
  719.     } // end func getValue
  720.  
  721.  
  722.     /**
  723.     * Deletes one or many variables from the block variable list.
  724.     *
  725.     * @param    string    Blockname
  726.     * @param    mixed     Name of one variable or array of variables
  727.     *                     ( array ( name => true ) ) to be stripped.
  728.     */
  729.     function deleteFromBlockvariablelist($block, $variables)
  730.     {
  731.         if (!is_array($variables)) {
  732.             $variables = array($variables => true);
  733.         }
  734.  
  735.         reset($this->blockvariables[$block]);
  736.         while (list($varname, $val) = each($this->blockvariables[$block])) {
  737.             if (isset($variables[$varname])) {
  738.                 unset($this->blockvariables[$block][$varname]);
  739.             }
  740.         }
  741.     } // end deleteFromBlockvariablelist
  742.  
  743.     /**
  744.     * Updates the variable list of a block.
  745.     *
  746.     * @param    string    Blockname
  747.     */
  748.     function updateBlockvariablelist($block)
  749.     {
  750.         preg_match_all( $this->variablesRegExp,
  751.                         $this->blocklist[$block], $regs
  752.                     );
  753.  
  754.         if (0 != count($regs[1])) {
  755.             foreach ($regs[1] as $k => $var) {
  756.                 $this->blockvariables[$block][$var] = true;
  757.             }
  758.         } else {
  759.             $this->blockvariables[$block] = array();
  760.         }
  761.  
  762.         // check if any inner blocks were found
  763.         if (isset($this->blockinner[$block]) &&
  764.             is_array($this->blockinner[$block]) &&
  765.             count($this->blockinner[$block]) > 0
  766.         ) {
  767.             /*
  768.              * loop through inner blocks, registering the variable
  769.              * placeholders in each
  770.              */
  771.             foreach($this->blockinner[$block] as $childBlock) {
  772.                 $this->updateBlockvariablelist($childBlock);
  773.             }
  774.         }
  775.  
  776.     } // end func updateBlockvariablelist
  777.  
  778.     /**
  779.     * Returns an array of blocknames where the given variable
  780.     * placeholder is used.
  781.     *
  782.     * @param    string    Variable placeholder
  783.     * @return    array    $parents    parents[0..n] = blockname
  784.     */
  785.     function findPlaceholderBlocks($variable)
  786.     {
  787.         $parents = array();
  788.         reset($this->blocklist);
  789.         while (list($blockname, $content) = each($this->blocklist)) {
  790.             reset($this->blockvariables[$blockname]);
  791.             while (
  792.                 list($varname, $val) = each($this->blockvariables[$blockname]))
  793.             {
  794.                 if ($variable == $varname) {
  795.                     $parents[] = $blockname;
  796.                 }
  797.             }
  798.         }
  799.  
  800.         return $parents;
  801.     } // end func findPlaceholderBlocks
  802.  
  803.     /**
  804.     * Handles warnings, saves them to $warn and prints them or
  805.     * calls die() depending on the flags
  806.     *
  807.     * @param    string    Warning
  808.     * @param    string    File where the warning occured
  809.     * @param    int       Linenumber where the warning occured
  810.     * @see      $warn, $printWarning, $haltOnWarning
  811.     */
  812.     function warning($message, $file = '', $line = 0)
  813.     {
  814.         $message = sprintf(
  815.                     'HTML_Template_ITX Warning: %s [File: %s, Line: %d]',
  816.                     $message,
  817.                     $file,
  818.                     $line
  819.                 );
  820.  
  821.         $this->warn[] = $message;
  822.  
  823.         if ($this->printWarning) {
  824.             print $message;
  825.         }
  826.  
  827.         if ($this->haltOnError) {
  828.             die($message);
  829.         }
  830.     } // end func warning
  831.  
  832. } // end class HTML_Template_ITX
  833. ?>